```html
<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>深入理解线程安全 - 技术小馆</title>
    <link rel="stylesheet" href="https://cdn.staticfile.org/font-awesome/6.4.0/css/all.min.css">
    <link rel="stylesheet" href="https://cdn.staticfile.org/tailwindcss/2.2.19/tailwind.min.css">
    <link href="https://fonts.googleapis.com/css2?family=Noto+Serif+SC:wght@400;500;600;700&family=Noto+Sans+SC:wght@300;400;500;700&display=swap" rel="stylesheet">
    <script src="https://cdn.jsdelivr.net/npm/mermaid@latest/dist/mermaid.min.js"></script>
    <style>
        body {
            font-family: 'Noto Sans SC', Tahoma, Arial, Roboto, "Droid Sans", "Helvetica Neue", "Droid Sans Fallback", "Heiti SC", "Hiragino Sans GB", Simsun, sans-serif;
            color: #333;
            line-height: 1.8;
        }
        .hero {
            background: linear-gradient(135deg, #f5f7fa 0%, #c3cfe2 100%);
        }
        .title-font {
            font-family: 'Noto Serif SC', serif;
        }
        .card {
            transition: transform 0.3s ease, box-shadow 0.3s ease;
        }
        .card:hover {
            transform: translateY(-5px);
            box-shadow: 0 10px 25px rgba(0,0,0,0.1);
        }
        .code-block {
            background-color: #f8f9fa;
            border-left: 4px solid #3b82f6;
        }
        .section-divider {
            position: relative;
            height: 80px;
            overflow: hidden;
        }
        .section-divider::before {
            content: "";
            position: absolute;
            left: 0;
            right: 0;
            top: 50%;
            border-top: 1px solid #e5e7eb;
        }
        .section-divider i {
            position: relative;
            z-index: 1;
            background: white;
            padding: 0 20px;
        }
        .concept-diagram {
            background: white;
            border-radius: 12px;
            padding: 20px;
            box-shadow: 0 4px 6px rgba(0,0,0,0.05);
        }
        .hover-grow {
            transition: transform 0.2s ease;
        }
        .hover-grow:hover {
            transform: scale(1.02);
        }
        .bg-primary {
            background-color: #3b82f6;
        }
        .text-primary {
            color: #3b82f6;
        }
    </style>
</head>
<body class="bg-gray-50">
    <!-- Hero Section -->
    <section class="hero py-20 px-4 md:px-0">
        <div class="container mx-auto max-w-5xl text-center">
            <h1 class="title-font text-4xl md:text-5xl font-bold mb-6 text-gray-800">深入理解线程安全</h1>
            <p class="text-xl md:text-2xl text-gray-600 mb-8 max-w-3xl mx-auto">
                多线程环境下的数据一致性、可靠性与系统稳定性
            </p>
            <div class="flex justify-center space-x-4">
                <span class="px-4 py-2 bg-white rounded-full text-sm font-medium text-gray-700 shadow-sm">
                    <i class="fas fa-lock mr-2"></i>并发控制
                </span>
                <span class="px-4 py-2 bg-white rounded-full text-sm font-medium text-gray-700 shadow-sm">
                    <i class="fas fa-shield-alt mr-2"></i>数据保护
                </span>
                <span class="px-4 py-2 bg-white rounded-full text-sm font-medium text-gray-700 shadow-sm">
                    <i class="fas fa-cogs mr-2"></i>同步机制
                </span>
            </div>
        </div>
    </section>

    <!-- Introduction Section -->
    <section class="py-12 px-4 md:px-0">
        <div class="container mx-auto max-w-5xl">
            <div class="bg-white rounded-xl shadow-md overflow-hidden p-8 hover-grow">
                <div class="flex items-start">
                    <div class="flex-shrink-0 bg-blue-100 rounded-full p-3 mr-4">
                        <i class="fas fa-info-circle text-blue-500 text-xl"></i>
                    </div>
                    <div>
                        <h2 class="title-font text-2xl font-bold mb-4 text-gray-800">线程安全的核心概念</h2>
                        <p class="text-gray-600 mb-4">
                            线程安全在软件开发中至关重要，尤其在多线程并发环境下。它涉及到数据的一致性、可靠性和系统的稳定性。维护线程安全的关键是通过合适的同步机制（如锁、原子操作、并发集合等）来保护共享资源。
                        </p>
                        <div class="bg-blue-50 border-l-4 border-blue-500 p-4 rounded mb-4">
                            <p class="text-gray-700">
                                <i class="fas fa-lightbulb text-blue-500 mr-2"></i>
                                <strong>举例来说</strong>，多人共享一台ATM取款机，若没有正确控制每个人的操作顺序和资源共享，可能会导致账户余额不正确或者出现取款冲突，而线程安全的设计就像是ATM机的智能控制系统，确保每个人的操作顺序和资源访问都是有序、安全的，避免了潜在的问题和冲突。
                            </p>
                        </div>
                    </div>
                </div>
            </div>
        </div>
    </section>

    <!-- Key Aspects Section -->
    <section class="py-12 px-4 md:px-0 bg-gray-50">
        <div class="container mx-auto max-w-5xl">
            <h2 class="title-font text-3xl font-bold mb-12 text-center text-gray-800">线程安全的五大关键方面</h2>
            
            <div class="grid md:grid-cols-2 gap-8">
                <!-- Atomicity -->
                <div class="bg-white rounded-xl shadow-md overflow-hidden p-6 card">
                    <div class="flex items-center mb-4">
                        <div class="bg-blue-100 rounded-full p-3 mr-4">
                            <i class="fas fa-atom text-blue-500 text-xl"></i>
                        </div>
                        <h3 class="title-font text-xl font-bold text-gray-800">原子性 (Atomicity)</h3>
                    </div>
                    <p class="text-gray-600">
                        确保操作是原子的，即不可分割的。在多线程环境下，需要保证某些操作的执行是完整的，不会被其他线程中断。Java中可以通过synchronized关键字、原子类(AtomicInteger等)实现原子操作。
                    </p>
                </div>
                
                <!-- Visibility -->
                <div class="bg-white rounded-xl shadow-md overflow-hidden p-6 card">
                    <div class="flex items-center mb-4">
                        <div class="bg-purple-100 rounded-full p-3 mr-4">
                            <i class="fas fa-eye text-purple-500 text-xl"></i>
                        </div>
                        <h3 class="title-font text-xl font-bold text-gray-800">可见性 (Visibility)</h3>
                    </div>
                    <p class="text-gray-600">
                        确保一个线程修改的状态对其他线程是可见的。当一个线程修改了共享状态时，其他线程应该能够及时看到这些修改。可以使用volatile关键字或同步机制保证可见性。
                    </p>
                </div>
                
                <!-- Ordering -->
                <div class="bg-white rounded-xl shadow-md overflow-hidden p-6 card">
                    <div class="flex items-center mb-4">
                        <div class="bg-green-100 rounded-full p-3 mr-4">
                            <i class="fas fa-sort-amount-down text-green-500 text-xl"></i>
                        </div>
                        <h3 class="title-font text-xl font-bold text-gray-800">有序性 (Ordering)</h3>
                    </div>
                    <p class="text-gray-600">
                        确保操作的执行顺序符合预期。在多线程环境下，操作的执行顺序可能会受到指令重排等因素的影响，需要通过同步机制来保证顺序性。
                    </p>
                </div>
                
                <!-- Mutual Exclusion -->
                <div class="bg-white rounded-xl shadow-md overflow-hidden p-6 card">
                    <div class="flex items-center mb-4">
                        <div class="bg-red-100 rounded-full p-3 mr-4">
                            <i class="fas fa-user-lock text-red-500 text-xl"></i>
                        </div>
                        <h3 class="title-font text-xl font-bold text-gray-800">互斥性 (Mutual Exclusion)</h3>
                    </div>
                    <p class="text-gray-600">
                        确保对共享资源的访问是互斥的，即同一时刻只能有一个线程访问共享资源，其他线程需要等待。可以通过锁机制实现互斥访问。
                    </p>
                </div>
            </div>
        </div>
    </section>

    <!-- Shared Resources Section -->
    <section class="py-12 px-4 md:px-0">
        <div class="container mx-auto max-w-5xl">
            <div class="flex flex-col md:flex-row items-center mb-12">
                <div class="md:w-1/2 mb-8 md:mb-0 md:pr-8">
                    <h2 class="title-font text-3xl font-bold mb-4 text-gray-800">共享资源与线程安全</h2>
                    <p class="text-gray-600 mb-4">
                        理解线程安全问题需要从共享资源的角度来考虑。在多线程环境下，多个线程可能同时访问和修改共享资源，如果不加以保护或者同步，就会出现竞态条件(Race Condition)导致的数据不一致性和不确定性。
                    </p>
                    <p class="text-gray-600">
                        共享资源可以是内存中的变量、对象、文件、数据库连接等。对于不同类型的共享资源，需要采取不同的线程安全措施。
                    </p>
                </div>
                <div class="md:w-1/2">
                    <div class="concept-diagram">
                        <img src="https://cdn.nlark.com/yuque/0/2024/png/21449790/1712026994241-f7455552-e2e8-463c-8d62-1f90575b8151.png" alt="共享资源图示" class="rounded-lg w-full h-auto shadow-md">
                    </div>
                </div>
            </div>
            
            <div class="grid md:grid-cols-2 gap-6 mt-8">
                <div class="bg-white p-6 rounded-lg shadow-sm border border-gray-100">
                    <h3 class="font-semibold text-lg mb-3 flex items-center">
                        <i class="fas fa-memory text-blue-500 mr-2"></i>
                        共享变量和对象
                    </h3>
                    <p class="text-gray-600">
                        对于普通的共享变量和对象，可以使用同步机制(如synchronized关键字或者Lock接口的实现类)来确保在同一时刻只有一个线程可以访问和修改。
                    </p>
                </div>
                
                <div class="bg-white p-6 rounded-lg shadow-sm border border-gray-100">
                    <h3 class="font-semibold text-lg mb-3 flex items-center">
                        <i class="fas fa-layer-group text-purple-500 mr-2"></i>
                        集合类
                    </h3>
                    <p class="text-gray-600">
                        在多线程环境下，使用非线程安全的集合类(如ArrayList、HashMap)可能会导致并发修改异常。可以使用线程安全的并发集合类(如ConcurrentHashMap)来代替。
                    </p>
                </div>
                
                <div class="bg-white p-6 rounded-lg shadow-sm border border-gray-100">
                    <h3 class="font-semibold text-lg mb-3 flex items-center">
                        <i class="fas fa-database text-green-500 mr-2"></i>
                        文件和数据库连接
                    </h3>
                    <p class="text-gray-600">
                        可以通过单例模式管理文件或数据库连接，或者使用连接池来避免并发访问问题。
                    </p>
                </div>
                
                <div class="bg-white p-6 rounded-lg shadow-sm border border-gray-100">
                    <h3 class="font-semibold text-lg mb-3 flex items-center">
                        <i class="fas fa-user-circle text-red-500 mr-2"></i>
                        线程本地变量
                    </h3>
                    <p class="text-gray-600">
                        对于每个线程独享的资源，可以使用ThreadLocal来保证线程安全，避免线程间的数据共享和竞争。
                    </p>
                </div>
            </div>
        </div>
    </section>

    <!-- Thread Safety Levels Section -->
    <section class="py-12 px-4 md:px-0 bg-gray-50">
        <div class="container mx-auto max-w-5xl">
            <h2 class="title-font text-3xl font-bold mb-12 text-center text-gray-800">线程安全性级别</h2>
            
            <div class="flex flex-col md:flex-row mb-8">
                <div class="md:w-1/2 mb-8 md:mb-0 md:pr-8">
                    <img src="https://cdn.nlark.com/yuque/0/2024/png/21449790/1712027055484-19879d60-667a-4f26-9bab-a60c27d8f3e4.png" alt="线程安全性级别" class="rounded-lg w-full h-auto shadow-md">
                </div>
                <div class="md:w-1/2">
                    <p class="text-gray-600 mb-6">
                        了解线程安全性的级别有助于选择合适的并发控制方式。常见的线程安全性级别包括不可变、绝对线程安全、相对线程安全和线程不安全等。
                    </p>
                    
                    <div class="space-y-4">
                        <div class="flex items-start">
                            <div class="flex-shrink-0 bg-blue-100 rounded-full p-2 mr-3">
                                <i class="fas fa-lock text-blue-500"></i>
                            </div>
                            <div>
                                <h3 class="font-semibold text-gray-800">不可变性 (Immutable)</h3>
                                <p class="text-gray-600 text-sm">
                                    不可变对象在多线程环境下是线程安全的，因为它们的状态不会被修改。如String、Integer等。
                                </p>
                            </div>
                        </div>
                        
                        <div class="flex items-start">
                            <div class="flex-shrink-0 bg-green-100 rounded-full p-2 mr-3">
                                <i class="fas fa-shield-alt text-green-500"></i>
                            </div>
                            <div>
                                <h3 class="font-semibold text-gray-800">无条件线程安全 (Unconditionally Thread-Safe)</h3>
                                <p class="text-gray-600 text-sm">
                                    在任何情况下都能安全地被多个线程同时访问而不需要额外的同步措施，如java.util.concurrent.atomic包中的原子类。
                                </p>
                            </div>
                        </div>
                        
                        <div class="flex items-start">
                            <div class="flex-shrink-0 bg-yellow-100 rounded-full p-2 mr-3">
                                <i class="fas fa-exclamation-triangle text-yellow-500"></i>
                            </div>
                            <div>
                                <h3 class="font-semibold text-gray-800">有条件线程安全 (Conditionally Thread-Safe)</h3>
                                <p class="text-gray-600 text-sm">
                                    在特定使用条件下是线程安全的，但在其他条件下可能需要额外同步，如Vector。
                                </p>
                            </div>
                        </div>
                        
                        <div class="flex items-start">
                            <div class="flex-shrink-0 bg-red-100 rounded-full p-2 mr-3">
                                <i class="fas fa-bug text-red-500"></i>
                            </div>
                            <div>
                                <h3 class="font-semibold text-gray-800">线程对立性 (Thread-Hostile)</h3>
                                <p class="text-gray-600 text-sm">
                                    在多线程环境下是不安全的，可能会导致数据损坏或者不一致的情况。
                                </p>
                            </div>
                        </div>
                    </div>
                </div>
            </div>
        </div>
    </section>

    <!-- Concurrency Control Section -->
    <section class="py-12 px-4 md:px-0">
        <div class="container mx-auto max-w-5xl">
            <h2 class="title-font text-3xl font-bold mb-8 text-center text-gray-800">并发控制手段</h2>
            
            <div class="mb-12">
                <img src="https://cdn.nlark.com/yuque/0/2024/png/21449790/1712027152160-cf22d264-4986-4969-bc29-430443418acd.png" alt="并发控制手段" class="rounded-lg w-full h-auto shadow-md mx-auto">
            </div>
            
            <div class="grid md:grid-cols-2 gap-8">
                <div class="bg-white p-8 rounded-xl shadow-md hover-grow">
                    <div class="flex items-center mb-4">
                        <div class="bg-purple-100 rounded-full p-3 mr-4">
                            <i class="fas fa-lock text-purple-500 text-xl"></i>
                        </div>
                        <h3 class="title-font text-xl font-bold text-gray-800">锁机制</h3>
                    </div>
                    <p class="text-gray-600 mb-4">
                        锁是最基本的并发控制手段之一，包括内置锁(synchronized关键字)和显式锁(如ReentrantLock)。锁可以确保在同一时刻只有一个线程可以访问被保护的代码块或资源，从而避免并发访问导致的数据竞争和不一致性。
                    </p>
                    <div class="bg-gray-50 p-4 rounded-lg">
                        <p class="text-sm text-gray-600 font-mono">
                            synchronized(lockObject) {<br>
                            &nbsp;&nbsp;// 临界区代码<br>
                            }
                        </p>
                    </div>
                </div>
                
                <div class="bg-white p-8 rounded-xl shadow-md hover-grow">
                    <div class="flex items-center mb-4">
                        <div class="bg-blue-100 rounded-full p-3 mr-4">
                            <i class="fas fa-atom text-blue-500 text-xl"></i>
                        </div>
                        <h3 class="title-font text-xl font-bold text-gray-800">原子类</h3>
                    </div>
                    <p class="text-gray-600 mb-4">
                        原子类是一种特殊的并发控制手段，它们提供了原子性操作，可以在不需要额外同步的情况下保证线程安全。常见的原子类包括AtomicInteger、AtomicLong等。它们利用了CPU的CAS(Compare and Swap)指令来实现线程安全的原子操作。
                    </p>
                    <div class="bg-gray-50 p-4 rounded-lg">
                        <p class="text-sm text-gray-600 font-mono">
                            AtomicInteger counter = new AtomicInteger(0);<br>
                            counter.incrementAndGet(); // 线程安全的原子操作
                        </p>
                    </div>
                </div>
                
                <div class="bg-white p-8 rounded-xl shadow-md hover-grow">
                    <div class="flex items-center mb-4">
                        <div class="bg-green-100 rounded-full p-3 mr-4">
                            <i class="fas fa-project-diagram text-green-500 text-xl"></i>
                        </div>
                        <h3 class="title-font text-xl font-bold text-gray-800">并发集合</h3>
                    </div>
                    <p class="text-gray-600 mb-4">
                        并发集合是线程安全的集合类，它们内部使用了锁或其他同步机制来保证多线程环境下的安全访问。常见的并发集合包括ConcurrentHashMap、ConcurrentSkipListMap等。它们提供了高效的并发操作，适用于高并发读写场景。
                    </p>
                    <div class="bg-gray-50 p-4 rounded-lg">
                        <p class="text-sm text-gray-600 font-mono">
                            ConcurrentHashMap&lt;String, Integer&gt; map = <br>
                            &nbsp;&nbsp;new ConcurrentHashMap&lt;&gt;();<br>
                            map.put("key", 1); // 线程安全的操作
                        </p>
                    </div>
                </div>
                
                <div class="bg-white p-8 rounded-xl shadow-md hover-grow">
                    <div class="flex items-center mb-4">
                        <div class="bg-orange-100 rounded-full p-3 mr-4">
                            <i class="fas fa-sync-alt text-orange-500 text-xl"></i>
                        </div>
                        <h3 class="title-font text-xl font-bold text-gray-800">同步器</h3>
                    </div>
                    <p class="text-gray-600 mb-4">
                        同步器是一种更加灵活和复杂的并发控制手段，可以支持不同的并发访问模式。常见的同步器包括Semaphore、CountDownLatch、CyclicBarrier等。它们可以实现更复杂的并发控制逻辑，如限流、等待一组线程完成等。
                    </p>
                    <div class="bg-gray-50 p-4 rounded-lg">
                        <p class="text-sm text-gray-600 font-mono">
                            CountDownLatch latch = new CountDownLatch(3);<br>
                            // 等待3个线程完成<br>
                            latch.await();
                        </p>
                    </div>
                </div>
            </div>
        </div>
    </section>

    <!-- Common Problems Section -->
    <section class="py-12 px-4 md:px-0 bg-gray-50">
        <div class="container mx-auto max-w-5xl">
            <h2 class="title-font text-3xl font-bold mb-12 text-center text-gray-800">常见线程安全问题与解决方案</h2>
            
            <div class="mb-8">
                <img src="https://cdn.nlark.com/yuque/0/2024/png/21449790/1712027227224-b132401e-818f-4c7b-a7af-49c8564bd0f0.png" alt="线程安全问题" class="rounded-lg w-full h-auto shadow-md mx-auto">
            </div>
            
            <div class="grid md:grid-cols-2 gap-6">
                <div class="bg-white p-6 rounded-lg shadow-sm">
                    <h3 class="font-bold text-lg mb-3 text-red-600">
                        <i class="fas fa-bolt mr-2"></i>竞态条件 (Race Condition)
                    </h3>
                    <p class="text-gray-600 mb-3">
                        多个线程同时访问共享资源，并且对资源的访问顺序不确定，导致不可预测的结果。
                    </p>
                    <div class="bg-red-50 p-3 rounded">
                        <p class="text-sm text-gray-700">
                            <span class="font-semibold">解决方案：</span> 使用同步机制，如锁(synchronized关键字或ReentrantLock类)来保护临界区，确保只有一个线程可以进入临界区执行。
                        </p>
                    </div>
                </div>
                
                <div class="bg-white p-6 rounded-lg shadow-sm">
                    <h3 class="font-bold text-lg mb-3 text-purple-600">
                        <i class="fas fa-skull-crossbones mr-2"></i>死锁 (Deadlock)
                    </h3>
                    <p class="text-gray-600 mb-3">
                        多个线程因为互相持有对方需要的资源而无法继续执行。
                    </p>
                    <div class="bg-purple-50 p-3 rounded">
                        <p class="text-sm text-gray-700">
                            <span class="font-semibold">解决方案：</span> 按顺序获取锁、避免嵌套锁、使用超时机制、破坏循环等方法来预防死锁的发生。
                        </p>
                    </div>
                </div>
                
                <div class="bg-white p-6 rounded-lg shadow-sm">
                    <h3 class="font-bold text-lg mb-3 text-blue-600">
                        <i class="fas fa-running mr-2"></i>数据竞争 (Data Race)
                    </h3>
                    <p class="text-gray-600 mb-3">
                        多个线程并发访问共享数据，至少有一个线程尝试写入数据，可能导致数据被破坏或结果不确定。
                    </p>
                    <div class="bg-blue-50 p-3 rounded">
                        <p class="text-sm text-gray-700">
                            <span class="font-semibold">解决方案：</span> 使用同步机制确保对共享数据的互斥访问，或使用并发数据结构(如ConcurrentHashMap)替代传统的线程不安全的数据结构。
                        </p>
                    </div>
                </div>
                
                <div class="bg-white p-6 rounded-lg shadow-sm">
                    <h3 class="font-bold text-lg mb-3 text-yellow-600">
                        <i class="fas fa-memory mr-2"></i>内存可见性 (Memory Visibility)
                    </h3>
                    <p class="text-gray-600 mb-3">
                        一个线程对共享变量的修改可能对其他线程不可见，导致读取到过期的值。
                    </p>
                    <div class="bg-yellow-50 p-3 rounded">
                        <p class="text-sm text-gray-700">
                            <span class="font-semibold">解决方案：</span> 使用volatile关键字确保变量的可见性，或使用synchronized关键字保证变量的更新和读取操作在同一个同步块中执行。
                        </p>
                    </div>
                </div>
                
                <div class="bg-white p-6 rounded-lg shadow-sm">
                    <h3 class="font-bold text-lg mb-3 text-green-600">
                        <i class="fas fa-exchange-alt mr-2"></i>ABA问题
                    </h3>
                    <p class="text-gray-600 mb-3">
                        在CAS操作中，一个值被改变、又被改回原值，但其他线程可能不知道这个过程。
                    </p>
                    <div class="bg-green-50 p-3 rounded">
                        <p class="text-sm text-gray-700">
                            <span class="font-semibold">解决方案：</span> 使用AtomicStampedReference等带有版本号的原子类来解决。
                        </p>
                    </div>
                </div>
                
                <div class="bg-white p-6 rounded-lg shadow-sm">
                    <h3 class="font-bold text-lg mb-3 text-indigo-600">
                        <i class="fas fa-tint mr-2"></i>线程泄漏 (Thread Leak)
                    </h3>
                    <p class="text-gray-600 mb-3">
                        线程没有被正确地释放，导致线程池中的线程数过多，最终耗尽系统资源。
                    </p>
                    <div class="bg-indigo-50 p-3 rounded">
                        <p class="text-sm text-gray-700">
                            <span class="font-semibold">解决方案：</span> 确保正确地关闭线程池，并及时释放线程持有的资源。
                        </p>
                    </div>
                </div>
            </div>
        </div>
    </section>

    <!-- Synchronization Section -->
    <section class="py-12 px-4 md:px-0">
        <div class="container mx-auto max-w-5xl">
            <div class="flex flex-col md:flex-row mb-12">
                <div class="md:w-1/2 mb-8 md:mb-0 md:pr-8">
                    <h2 class="title-font text-3xl font-bold mb-6 text-gray-800">同步与锁机制</h2>
                    <p class="text-gray-600 mb-4">
                        同步机制用于协调多个线程对共享资源的访问，以避免竞态条件和数据不一致的问题。Java提供了多种同步机制，包括synchronized关键字、ReentrantLock类、ReadWriteLock等。
                    </p>
                    <p class="text-gray-600 mb-4">
                        锁是同步机制的重要组成部分，用于控制对共享资源的访问。常见的锁包括对象内置锁(synchronized关键字)、显式锁(ReentrantLock类)、读写锁(ReadWriteLock接口)等。
                    </p>
                    <div class="bg-blue-50 border-l-4 border-blue-500 p-4 rounded">
                        <p class="text-gray-700">
                            <i class="fas fa-lightbulb text-blue-500 mr-2"></i>
                            <strong>可重入性</strong>是锁的重要属性，它允许同一个线程多次获取同一把锁而不会发生死锁。Java中的synchronized关键字和ReentrantLock类都支持可重入性。
                        </p>
                    </div>
                </div>
                <div class="md:w-1/2">
                    <img src="https://cdn.nlark.com/yuque/0/2024/png/21449790/1712027409010-d61257fb-a066-4ca0-9e22-9164efa5c953.png" alt="同步与锁机制" class="rounded-lg w-full h-auto shadow-md">
                </div>
            </div>
            
            <div class="bg-white rounded-xl shadow-md overflow-hidden p-8 mb-12">
                <h3 class="title-font text-xl font-bold mb-6 flex items-center">
                    <i class="fas fa-code text-blue-500 mr-3"></i>
                    Java同步示例
                </h3>
                <div class="code-block p-4 rounded-lg mb-4">
                    <pre class="text-sm text-gray-800 font-mono overflow-x-auto">
<code>public class Counter {
    private int count = 0;

    // 使用synchronized关键字保护临界区
    public synchronized void increment() {
        count++;
    }

    public synchronized void decrement() {
        count--;
    }

    public int getCount() {
        return count;
    }
}

public class Main {
    public static void main(String[] args) {
        Counter counter = new Counter();

        // 创建多个线程对计数器进行增减操作
        Thread incrementThread = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        });

        Thread decrementThread = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.decrement();
            }
        });

        incrementThread.start();
        decrementThread.start();

        try {
            incrementThread.join();
            decrementThread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Final count: " + counter.getCount());
    }
}</code>
                    </pre>
                </div>
                <p class="text-gray-600">
                    在这个示例中，Counter类中的increment()和decrement()方法都使用了synchronized关键字来保护对count变量的操作，确保对count的增减操作是原子的，从而避免了竞态条件和数据不一致的问题。
                </p>
            </div>
        </div>
    </section>

    <!-- Atomicity Visibility Ordering Section -->
    <section class="py-12 px-4 md:px-0 bg-gray-50">
        <div class="container mx-auto max-w-5xl">
            <h2 class="title-font text-3xl font-bold mb-12 text-center text-gray-800">原子性、可见性与有序性</h2>
            
            <div class="mb-8">
                <img src="https://cdn.nlark.com/yuque/0/2024/png/21449790/1712027441902-124359ee-4d80-40fe-be36-827dcdd7bd54.png" alt="原子性、可见性与有序性" class="rounded-lg w-full h-auto shadow-md mx-auto">
            </div>
            
            <div class="grid md:grid-cols-3 gap-6">
                <div class="bg-white p-6 rounded-xl shadow-md hover-grow">
                    <div class="flex items-center mb-4">
                        <div class="bg-red-100 rounded-full p-3 mr-4">
                            <i class="fas fa-atom text-red-500 text-xl"></i>
                        </div>
                        <h3 class="title-font text-xl font-bold text-gray-800">原子性</h3>
                    </div>
                    <p class="text-gray-600">
                        原子性是指一个操作是不可中断的，要么全部执行成功，要么全部不执行。在多线程环境中，如果一个操作涉及多个步骤，那么这个操作要么全部完成，要么全部不完成，不存在部分完成的情况。
                    </p>
                    <div class="mt-4 bg-gray-50 p-3 rounded">
                        <p class="text-sm text-gray-700">
                            <span class="font-semibold">实现方式：</span> synchronized关键字、Atomic包中的原子类、锁机制等。
                        </p>
                    </div>
                </div>
                
                <div class="bg-white p-6 rounded-xl shadow-md hover-grow">
                    <div class="flex items-center mb-4">
                        <div class="bg-blue-100 rounded-full p-3 mr-4">
                            <i class="fas fa-eye text-blue-500 text-xl"></i>
                        </div>
                        <h3 class="title-font text-xl font-bold text-gray-800">可见性</h3>
                    </div>
                    <p class="text-gray-600">
                        可见性是指当一个线程修改了共享变量的值后，其他线程能够立即看到修改后的值。由于线程之间的缓存不一致性以及指令重排序等原因，一个线程对共享变量的修改并不一定会立即对其他线程可见。
                    </p>
                    <div class="mt-4 bg-gray-50 p-3 rounded">
                        <p class="text-sm text-gray-700">
                            <span class="font-semibold">实现方式：</span> volatile关键字、synchronized关键字、Lock锁等。
                        </p>
                    </div>
                </div>
                
                <div class="bg-white p-6 rounded-xl shadow-md hover-grow">
                    <div class="flex items-center mb-4">
                        <div class="bg-green-100 rounded-full p-3 mr-4">
                            <i class="fas fa-sort-amount-down text-green-500 text-xl"></i>
                        </div>
                        <h3 class="title-font text-xl font-bold text-gray-800">有序性</h3>
                    </div>
                    <p class="text-gray-600">
                        有序性是指程序执行的顺序与代码的书写顺序一致。由于指令重排序和内存屏障等优化手段的存在，程序执行的顺序可能与代码的书写顺序不一致，导致出现意料之外的结果。
                    </p>
                    <div class="mt-4 bg-gray-50 p-3 rounded">
                        <p class="text-sm text-gray-700">
                            <span class="font-semibold">实现方式：</span> volatile关键字、synchronized关键字、Lock锁等。
                        </p>
                    </div>
                </div>
            </div>
            
            <div class="bg-white rounded-xl shadow-md overflow-hidden p-8 mt-12">
                <h3 class="title-font text-xl font-bold mb-6 flex items-center">
                    <i class="fas fa-code text-purple-500 mr-3"></i>
                    volatile关键字示例
                </h3>
                <div class="code-block p-4 rounded-lg mb-4">
                    <pre class="text-sm text-gray-800 font-mono overflow-x-auto">
<code>public class VisibilityDemo {
    private volatile boolean flag = false;

    public void toggleFlag() {
        flag = !flag; // 切换标志位的值
    }

    public boolean isFlag() {
        return flag; // 获取标志位的值
    }

    public static void main(String[] args) {
        VisibilityDemo demo = new VisibilityDemo();

        // 线程1：不断地切换标志位的值
        Thread thread1 = new Thread(() -> {
            while (true) {
                demo.toggleFlag();
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        // 线程2：检查标志位的值，如果为true则输出日志
        Thread thread2 = new Thread(() -> {
            while (true) {
                if (demo.isFlag()) {
                    System.out.println("Flag is true");
                }
            }
        });

        thread1.start();
        thread2.start();
    }
}</code>
                    </pre>
                </div>
                <p class="text-gray-600">
                    在上述示例中，使用volatile修饰的flag变量确保了线程之间对该变量的可见性，从而保证了线程2能够立即看到线程1修改flag变量的结果。
                </p>
            </div>
        </div>
    </section>

    <!-- Summary Section -->
    <section class="py-12 px-4 md:px-0">
        <div class="container mx-auto max-w-5xl">
            <div class="bg-gradient-to-r from-blue-500 to-indigo-600 rounded-xl shadow-xl p-8 text-white">
                <h2 class="title-font text-3xl font-bold mb-6">线程安全总结</h2>
                <div class="grid md:grid-cols-2 gap-8">
                    <div>
                        <h3 class="font-bold text-xl mb-4 flex items-center">
                            <i class="fas fa-check-circle mr-3"></i>
                            关键要点
                        </h3>
                        <ul class="space-y-3">
                            <li class="flex items-start">
                                <i class="fas fa-check mr-2 mt-1"></i>
                                <span>线程安全是多线程编程中的核心问题，涉及数据一致性、可靠性和系统稳定性</span>
                            </li>
                            <li class="flex items-start">
                                <i class="fas fa-check mr-2 mt-1"></i>
                                <span>线程安全的三大特性：原子性、可见性、有序性</span>
                            </li>
                            <li class="flex items-start">
                                <i class="fas fa-check mr-2 mt-1"></i>
                                <span>共享资源是线程安全问题的根源，需要合理保护</span>
                            </li>
                            <li class="flex items-start">
                                <i class="fas fa-check mr-2 mt-1"></i>
                                <span>了解不同线程安全性级别有助于选择合适的并发控制方式</span>
                            </li>
                        </ul>
                    </div>
                    <div>
                        <h3 class="font-bold text-xl mb-4 flex items-center">
                            <i class="fas fa-tools mr-3"></i>
                            最佳实践
                        </h3>
                        <ul class="space-y-3">
                            <li class="flex items-start">
                                <i class="fas fa-wrench mr-2 mt-1"></i>
                                <span>优先使用不可变对象和线程安全类</span>
                            </li>
                            <li class="flex items-start">
                                <i class="fas fa-wrench mr-2 mt-1"></i>
                                <span>合理选择并发控制手段(锁、原子类、并发集合等)</span>
                            </li>
                            <li class="flex items-start">
                                <i class="fas fa-wrench mr-2 mt-1"></i>
                                <span>避免常见的线程安全问题(死锁、竞态条件等)</span>
                            </li>
                            <li class="flex items-start">
                                <i class="fas fa-wrench mr-2 mt-1"></i>
                                <span>在保证线程安全的前提下，考虑性能优化</span>
                            </li>
                        </ul>
                    </div>
                </div>
            </div>
        </div>
    </section>

    <!-- Footer -->
    <footer class="bg-gray-900 text-gray-300 py-8 px-4">
        <div class="container mx-auto max-w-5xl">
            <div class="flex flex-col md:flex-row justify-between items-center">
                <div class="mb-4 md:mb-0">
                    <h3 class="text-xl font-bold text-white mb-2">技术小馆</h3>
                    <p class="text-gray-400">分享编程知识与技术见解</p>
                </div>
                <div>
                    <a href="http://www.yuque.com/jtostring" class="text-gray-300 hover:text-white transition duration-300">
                        <i class="fas fa-globe mr-2"></i>http://www.yuque.com/jtostring
                    </a>
                </div>
            </div>
            <div class="border-t border-gray-800 mt-6 pt-6 text-sm text-center text-gray-500">
                &copy; 2023 技术小馆. 保留所有权利.
            </div>
        </div>
    </footer>

    <script>
        mermaid.initialize({
            startOnLoad: true,
            theme: 'default',
            flowchart: {
                useMaxWidth: true,
                htmlLabels: true,
                curve: 'basis'
            }
        });
    </script>
</body>
</html>
```